import {
    apiClient,
    itemsApi,
    categoriesApi,
    locationsApi,
    statisticsApi
} from './apiService';

import {
    mockItems,
    mockCategories,
    mockLocations,
    mockStatuses,
    getItems,
    getItemById
} from '../mock';

// 统一的错误处理与回退逻辑
const withFallback = async (apiCall, fallbackData) => {
    try {
        // 尝试从API获取数据
        const response = await apiCall();
        // 如果API调用成功且返回了有效数据
        if (response && response.code === 200 && response.data) {
            console.log('使用后端数据');
            return {
                success: true,
                data: response.data,
                source: 'api'
            };
        } else {
            throw new Error('API响应格式不正确');
        }
    } catch (error) {
        console.warn('API调用失败，使用模拟数据', error);
        // 如果API调用失败，返回模拟数据

        // 确保fallbackData不为空，否则提供默认空数组
        const safeData = fallbackData || [];

        // 在控制台显示回退数据，帮助调试
        console.log('回退到模拟数据:', safeData);

        return {
            success: true,
            data: safeData,
            source: 'mock'
        };
    }
};

// 物品相关服务
export const itemService = {
    // 获取物品列表
    async getItems(params = {}) {
        try {
            const apiResponse = await itemsApi.getItems(params);

            // 检查后端响应结构
            if (apiResponse && apiResponse.code === 200 && apiResponse.data && Array.isArray(apiResponse.data.records)) {
                console.log(`后端返回${apiResponse.data.records.length}条物品记录`);
                console.log('分页信息:', {
                    总数: apiResponse.data.total,
                    当前页: apiResponse.data.current,
                    每页大小: apiResponse.data.size,
                    总页数: apiResponse.data.pages
                });

                return {
                    success: true,
                    items: apiResponse.data.records, // 使用 records 而不是 list
                    pagination: {
                        total: apiResponse.data.total || apiResponse.data.records.length, // 确保total存在
                        currentPage: apiResponse.data.current || 1, // 使用 current 或 page
                        pageSize: apiResponse.data.size || params.pageSize || 12, // 使用 size 或 pageSize，默认改为12
                        totalPages: apiResponse.data.pages || Math.ceil((apiResponse.data.total || apiResponse.data.records.length) / (apiResponse.data.size || params.pageSize || 12))
                    },
                    source: 'api'
                };
            } else {
                console.error('API响应格式不正确或缺少数据:', apiResponse)
                throw new Error('API响应格式不正确')
            }
        } catch (error) {
            console.warn('获取物品列表失败，使用模拟数据', error);
            // 使用模拟数据
            const mockResult = getItems(params);
            console.log(`模拟数据返回${mockResult.items.length}条物品记录`);
            return {
                success: true,
                ...mockResult,
                source: 'mock',
                error: error.message
            };
        }
    },

    // 获取所有物品（不分页）
    async getAllItems(locationId) {
        try {
            const apiResponse = await itemsApi.getAllItems(locationId);

            // 检查后端响应结构
            if (apiResponse && apiResponse.code === 200 && apiResponse.data) {
                return {
                    success: true,
                    items: apiResponse.data,
                    source: 'api'
                };
            } else {
                console.error('API响应格式不正确或缺少数据:', apiResponse);
                throw new Error('API响应格式不正确');
            }
        } catch (error) {
            console.warn('获取所有物品失败，使用模拟数据', error);
            // 使用模拟数据，但不进行分页处理
            const allItems = getItems({ specificLocation: locationId }).items;
            return {
                success: true,
                items: allItems,
                source: 'mock'
            };
        }
    },

    // 获取单个物品
    async getItem(id) {
        return withFallback(
            () => itemsApi.getItem(id),
            getItemById(id)
        );
    },

    // 创建物品
    async createItem(item) {
        try {
            console.log('调用itemsApi.createItem，发送数据:', JSON.stringify(item));
            // 添加超时处理
            const timeout = 8000; // 8秒超时
            let timeoutId;

            const timeoutPromise = new Promise((_, reject) => {
                timeoutId = setTimeout(() => {
                    reject(new Error('请求超时，可能是网络问题或后端服务未运行'));
                }, timeout);
            });

            // 使用Promise.race比较请求和超时
            const response = await Promise.race([
                itemsApi.createItem(item),
                timeoutPromise
            ]);

            // 清除超时定时器
            clearTimeout(timeoutId);

            console.log('接收到createItem响应:', response);

            if (response && response.code === 200) {
                console.log('创建物品成功(API):', response.data?.id);
                return { success: true, id: response.data?.id, source: 'api' };
            }

            console.error('API返回错误码:', response?.code, '错误信息:', response?.message);
            // 如果API返回错误，但不是网络错误，返回错误信息
            return {
                success: false,
                message: response?.message || '添加失败',
                source: 'api'
            };
        } catch (error) {
            console.warn('创建物品失败，错误详情:', error);
            console.warn('错误名称:', error.name);
            console.warn('错误消息:', error.message);
            if (error.response) {
                console.warn('错误响应状态:', error.response.status);
                console.warn('错误响应数据:', JSON.stringify(error.response.data));
            }

            console.warn('使用模拟数据创建物品');
            // 创建模拟物品
            const newId = Date.now();
            const newItem = { id: newId, ...item };
            mockItems.unshift(newItem);
            return {
                success: true,
                id: newId,
                item: newItem,
                source: 'mock'
            };
        }
    },

    // 更新物品
    async updateItem(id, item) {
        try {
            const response = await itemsApi.updateItem(id, item);
            if (response && response.code === 200) {
                return { success: true, source: 'api' };
            }
            throw new Error(response?.message || '更新失败'); // 增加可选链
        } catch (error) {
            console.warn('更新物品失败，使用模拟数据', error);
            // 更新模拟物品
            const idToFind = typeof id === 'string' &&
                (id.startsWith('ls') || id.startsWith('ex') || id.startsWith('xp'))
                ? id
                : parseInt(id);

            const index = mockItems.findIndex(item => item.id === idToFind);
            if (index !== -1) {
                mockItems[index] = { ...mockItems[index], ...item };
                return {
                    success: true,
                    item: mockItems[index],
                    source: 'mock'
                };
            }
            return {
                success: false,
                message: '物品不存在',
                source: 'mock'
            };
        }
    },

    // 删除物品
    async deleteItem(id) {
        try {
            const response = await itemsApi.deleteItem(id);
            if (response && response.code === 200) {
                return { success: true, source: 'api' };
            }
            throw new Error(response?.message || '删除失败'); // 增加可选链
        } catch (error) {
            console.warn('删除物品失败，使用模拟数据', error);
            // 删除模拟物品
            const index = mockItems.findIndex(item => item.id === id);
            if (index !== -1) {
                mockItems.splice(index, 1);
                return {
                    success: true,
                    source: 'mock'
                };
            }
            return {
                success: false,
                message: '物品不存在',
                source: 'mock'
            };
        }
    }
};

// 分类相关服务
export const categoryService = {
    // 获取所有分类
    async getCategories() {
        return withFallback(
            () => categoriesApi.getCategories(),
            mockCategories
        );
    },

    // 创建分类
    async createCategory(category) {
        try {
            const response = await categoriesApi.createCategory(category);
            if (response && response.code === 200) {
                return { success: true, id: response.data.id, source: 'api' };
            }
            throw new Error(response.message || '添加分类失败');
        } catch (error) {
            console.warn('创建分类失败，使用模拟数据', error);
            // 添加到模拟数据
            const newId = mockCategories.length + 1;
            const newCategory = { id: newId, ...category };
            mockCategories.push(newCategory);
            return {
                success: true,
                id: newId,
                category: newCategory,
                source: 'mock'
            };
        }
    }
};

// 位置相关服务
export const locationService = {

    // 创建位置
    async createLocation(location) {
        try {
            const response = await locationsApi.createLocation(location);
            if (response && response.code === 200) {
                return { success: true, id: response.data.id, source: 'api' };
            }
            throw new Error(response.message || '添加位置失败');
        } catch (error) {
            console.warn('创建位置失败，使用模拟数据', error);
            // 添加到模拟数据
            const newId = mockLocations.length + 1;
            const newLocation = { id: newId, ...location };
            mockLocations.push(newLocation);
            return {
                success: true,
                id: newId,
                location: newLocation,
                source: 'mock'
            };
        }
    }
};

// 状态相关服务
export const statusService = {
    // 获取所有状态
    async getStatuses() {
        try {
            const response = await apiClient.get('/statuses');
            if (response && response.code === 200) {
                return { success: true, data: response.data, source: 'api' };
            }
            throw new Error(response.message || '获取状态失败');
        } catch (error) {
            console.warn('获取状态列表失败，使用模拟数据', error);
            return {
                success: true,
                data: mockStatuses,
                source: 'mock'
            };
        }
    }
};

export default {
    itemService,
    categoryService,
    locationService,
    statusService
}; 